home *** CD-ROM | disk | FTP | other *** search
/ Programming a Multiplayer FPS in DirectX / Programming a Multiplayer FPS in DirectX (Companion CD).iso / DirectX / dxsdk_oct2004.exe / dxsdk.exe / Utilities / Content Creation Tool Plug-Ins / Maya / Sources / MayaInterface.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2004-09-27  |  26.7 KB  |  1,013 lines
  1. //-----------------------------------------------------------------------------
  2. // INCLUDE FILES
  3. //-----------------------------------------------------------------------------
  4. #include "dxstdafx.h"
  5.  
  6. #include "d3d9.h"
  7. #include "d3dx9.h"
  8.  
  9. #include "MayaInterface.h"
  10.  
  11. #include <windows.h>
  12. #include <windowsx.h>
  13. #include <commdlg.h>
  14. #include <assert.h>
  15. #include <stdio.h>
  16. #include <memory.h>
  17. #include <string.h>
  18. #include <wchar.h>
  19. #include <stdlib.h>
  20. #include <math.h>
  21. #include <malloc.h>
  22. #include <tchar.h>
  23.  
  24. // Maya API
  25. #include <maya/MPxNode.h>
  26. #include <maya/MPxHwShaderNode.h>
  27. #include <maya/MString.h>
  28. #include <maya/MTypeId.h>
  29. #include <maya/MPlug.h>
  30. #include <maya/MDataBlock.h>
  31. #include <maya/MDataHandle.h>
  32. #include <maya/MArrayDataHandle.h>
  33. #include <maya/MFnNumericAttribute.h>
  34. #include <maya/MFnLightDataAttribute.h>
  35. #include <maya/MFnMessageAttribute.h>
  36. #include <maya/MFnCompoundAttribute.h>
  37. #include <maya/MFnTypedAttribute.h>
  38. #include <maya/MFloatVector.h>
  39. #include <maya/MFnPlugin.h>
  40. #include <maya/MFnStringData.h>
  41. #include <maya/MFnDoubleArrayData.h>
  42. #include <maya/MSceneMessage.h>
  43. #include <maya/MNodeMessage.h>
  44. #include <maya/MDagMessage.h>
  45. #include <maya/MDGMessage.h>
  46. #include <maya/MUiMessage.h>
  47. #include <maya/MEventMessage.h>
  48. #include <maya/MModelMessage.h>
  49. #include <maya/MSelectionList.h>
  50. #include <maya/MItDag.h>
  51. #include <maya/MDagPathArray.h>
  52. #include <maya/MIntArray.h>
  53. #include <maya/MItDependencyNodes.h>
  54. #include <maya/MFnCamera.h>
  55. #include <maya/MTime.h>
  56. #include <maya/MMatrix.h>
  57. #include <maya/MItSelectionList.h>
  58. #include <maya/MItDependencyGraph.h>
  59.  
  60.  
  61. #define DXCC_EXPORTER "X-File"
  62. #define DXCC_SHADER "DirectXShader"
  63. #define DXCC_PREVIEW_TOGGLE "DXCCPreviewToggle"
  64. #define DXCC_GATHER_ANIMATION "DXCCGatherAnimation"
  65. #define DXCC_REBUILD_SCENE "DXCCRebuildScene"
  66. #define DXCC_REBUILD_SELECTED "DXCCRebuildSelected"
  67. #define DXCC_EXPORT_SCENE "DXCCExportScene"
  68. #define DXCC_EXPORT_SELECTED "DXCCExportSelected"
  69. #define DXCC_VIEW_FLOATING "DXCCFloatingView"
  70. #define DXCC_VIEW_TOP "DXCCTopView"
  71. #define DXCC_VIEW_SIDE "DXCCSideView"
  72. #define DXCC_VIEW_FRONT "DXCCFrontView"
  73. #define DXCC_VIEW_PERSP "DXCCPerspectiveView"
  74.  
  75. MTypeId  DirectXShader::id( 0x68038 );
  76. MObject  DirectXShader::aDXCCCommand;
  77. MObject  DirectXShader::aDXCCHandle;
  78. MObject  DirectXShader::aColor;
  79. MObject  DirectXShader::aColorR;
  80. MObject  DirectXShader::aColorG;
  81. MObject  DirectXShader::aColorB;
  82. MObject  DirectXShader::aOutColor;
  83. MObject  DirectXShader::aOutColorR;
  84. MObject  DirectXShader::aOutColorG;
  85. MObject  DirectXShader::aOutColorB;
  86. MObject  DirectXShader::aNormalCamera;
  87. MObject  DirectXShader::aNormalCameraX;
  88. MObject  DirectXShader::aNormalCameraY;
  89. MObject  DirectXShader::aNormalCameraZ;
  90.  
  91. MStatus DCCUnifiedViewerCommand ( const MArgList& Arg, const char* strView);
  92. HANDLE    DirectXShader::FxDialogEvent= NULL;
  93.  
  94. //-----------------------------------------------------------------------------
  95. // MAYA PLUGIN FUNCTIONS
  96. //-----------------------------------------------------------------------------
  97.  
  98. MString MakeNameExportable(MString &in)
  99. {
  100.     const char *inConv= in.asChar();
  101.     char outConv[MAX_PATH+1];
  102.     for(UINT i= 0; i < in.length() && i < MAX_PATH; i++)
  103.     {
  104.         if(isalnum( inConv[i] )//alphanumeric//A û Z, a û z, or 0 û 9
  105.         || (inConv[i] == '_'))
  106.             outConv[i]= inConv[i];
  107.         else
  108.             outConv[i]= '_';
  109.     }
  110.  
  111.     if(in.length() <= MAX_PATH)
  112.         outConv[in.length()]= '\0';
  113.     else
  114.         outConv[MAX_PATH]= '\0';
  115.     
  116.     return MString(outConv);
  117. }
  118.  
  119.  
  120.  
  121. void CMayaPreviewPipeline::Callback_NodeParentingChange( MDagMessage::DagMessage dagMsg, MDagPath &child, MDagPath &parent, void * clientData )
  122. {
  123.     g_PreviewPipeline.Tag_Reparent( dagMsg, child, parent, true );
  124.     return;
  125. }
  126.  
  127. void CMayaPreviewPipeline::Callback_NodeAttributeChanged( MNodeMessage::AttributeMessage msg,
  128.     MPlug & plug,
  129.     MPlug & otherPlug,
  130.     void* clientData )
  131. {
  132.     g_PreviewPipeline.Tag_Dirty(msg, plug, otherPlug);
  133.     return;
  134. }
  135.  
  136.  
  137.  
  138.  
  139. void CMayaPreviewPipeline::Callback_NodeNameChange( MObject & node, void* clientData )
  140. {
  141.     g_PreviewPipeline.Tag_Rename(node);
  142.     return;
  143. }
  144.  
  145. void CMayaPreviewPipeline::Callback_SceneIdle( void* clientData )
  146. {
  147.     g_PreviewPipeline.Scene_Update(false);
  148.     return;
  149. }
  150.  
  151. //add resourced on newed item (not loaded)
  152. void CMayaPreviewPipeline::Callback_NodeAdded( MObject & node, void* clientData )
  153. {
  154.     g_PreviewPipeline.Tag_Add(  node );
  155.     return;
  156. }
  157.  
  158.  
  159. //void CMayaPreviewPipeline::Callback_NodeRemoved( MObject & node, MDGModifier & modifier, void* clientData )
  160. void CMayaPreviewPipeline::Callback_NodeRemoved( MObject & node, void* clientData )
  161. {
  162.     g_PreviewPipeline.Tag_Remove(node);
  163.     return;
  164. }
  165.  
  166. void CMayaPreviewPipeline::Callback_SceneSave(void* clientData )
  167. {
  168.     CPipelineLock SceneLock;
  169.     g_PreviewPipeline.SceneReadLock(true, SceneLock);
  170.  
  171.     for(MItDependencyNodes iter; !iter.isDone(); iter.next())
  172.     {
  173.         MFnDependencyNode depNode(iter.item());
  174.         if(depNode.typeId() == DirectXShader::id)
  175.         {
  176.             g_PreviewPipeline.Material_Save(depNode.object());
  177.         }
  178.     }
  179.  
  180.     g_PreviewPipeline.SceneReadUnlock(SceneLock);
  181. }
  182.  
  183. void CMayaPreviewPipeline::Callback_ScenePreload(void* clientData )
  184. {
  185.     g_PreviewPipeline.UI_SetPreviewState(false);
  186.     g_PreviewPipeline.Scene_Deregister();
  187.  
  188.     g_PreviewPipeline.CallbackId_AfterOpen= MSceneMessage::addCallback( MSceneMessage::Message::kAfterOpen, CMayaPreviewPipeline::Callback_ScenePostload, NULL, NULL);
  189. }
  190.  
  191. //add resourced on scene update or reload
  192. void CMayaPreviewPipeline::Callback_ScenePostload(void* clientData )
  193. {
  194.     MMessage::removeCallback(g_PreviewPipeline.CallbackId_AfterOpen);
  195.  
  196.     g_PreviewPipeline.Scene_Register();
  197.  
  198.     CPipelineLock SceneLock;
  199.     g_PreviewPipeline.SceneWriteLock(true, SceneLock);
  200.  
  201.     for(MItDependencyNodes iter; !iter.isDone(); iter.next())
  202.     {
  203.         MFnDependencyNode depNode(iter.item());
  204.         if(depNode.typeId() == DirectXShader::id)
  205.         {
  206.             g_PreviewPipeline.Material_Restore(depNode.object());
  207.         }
  208.     }
  209.  
  210.     g_PreviewPipeline.Scene_Update(TRUE);
  211.  
  212.     g_PreviewPipeline.SceneWriteUnlock(SceneLock);
  213.  
  214.  
  215. };
  216.  
  217.  
  218.  
  219. MStatus DCCRebuildSelectedCommand::doIt ( const MArgList& Arg)
  220. {
  221.  
  222.     MStatus stat;
  223.     MSelectionList    list;
  224.     MGlobal::getActiveSelectionList(list);
  225.     
  226.     DXCC_DPF_REPORT(TEXT("REFRESH SELECTION"));
  227.     MGlobal::displayInfo("DirectX Rebuilding Selected (currently previewed items only)");
  228.  
  229.     for (UINT i=0; i < list.length(); i++)
  230.     {
  231.         MDagPath dagPath;
  232.         UINT iRemove;
  233.  
  234.         list.getDagPath(i, dagPath);
  235.  
  236.         if(g_PreviewPipeline.TagContainer.Find(dagPath, &iRemove, NULL))
  237.         {
  238.             g_PreviewPipeline.TagContainer.Erase(iRemove);
  239.         }
  240.  
  241.         g_PreviewPipeline.TagContainer.Add(dagPath, NULL, NULL);
  242.  
  243.     }
  244.     g_PreviewPipeline.Scene_Update(true);
  245.  
  246.  
  247.     return stat;
  248. }
  249.  
  250. MStatus DXCCRebuildSceneCommand::doIt ( const MArgList& Arg)
  251. {
  252.  
  253.     MStatus stat = MS::kSuccess;
  254.  
  255.     DXCC_DPF_REPORT(TEXT("REFRESH SCENE"));
  256.     MGlobal::displayInfo("DirectX Rebuilding Scene");
  257.  
  258.     g_PreviewPipeline.Scene_Deregister();
  259.     g_PreviewPipeline.Scene_Register();
  260.  
  261.  
  262.  
  263.     return stat;
  264. }
  265.  
  266. MStatus DCCUnifiedViewerCommand ( const MArgList& Arg, const char* strView)
  267. {
  268.     //HRESULT hr= S_OK;
  269.     HWND renderwnd= NULL;
  270.     MDagPath MayaCamera;
  271.  
  272.  
  273.     if(strView && (strView[0] != '\0'))
  274.     {
  275.         M3dView ourView;
  276.         M3dView::get3dView(0,ourView);
  277.  
  278.         for(UINT iView= 0; iView < M3dView::numberOf3dViews(); iView++)
  279.         {
  280.             M3dView::get3dView(iView, ourView);
  281.             ourView.getCamera(MayaCamera);
  282.             MayaCamera.pop();
  283.             if(MayaCamera.partialPathName() == MString(strView))
  284.             {
  285.                 break;
  286.             }
  287.         }
  288.  
  289.         renderwnd= (HWND)ourView.window();
  290.     }
  291.  
  292.     g_PreviewPipeline.g_Viewer.BindToWindow(renderwnd); 
  293.  
  294. //e_Exit:
  295.  
  296.     return MS::kSuccess;
  297. }
  298.  
  299. MStatus DXCCGatherAnimationCommand::doIt ( const MArgList& Arg )
  300. {
  301.     MStatus stat= MS::kSuccess;
  302.  
  303.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  304.  
  305.  
  306.     g_PreviewPipeline.Scene_Update_Animation();
  307.  
  308.     DXCC_ASSERT_EXCEPTIONS_END()
  309.  
  310.     return stat;
  311. }
  312.  
  313.  
  314. MStatus DXCCPreviewToggleCommand::doIt ( const MArgList& Arg )
  315. {
  316.     MStatus stat= MS::kSuccess;
  317.  
  318.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  319.  
  320.  
  321.     if(1 <= Arg.length())
  322.     {
  323.         bool bPreview= Arg.asBool(0);
  324.         g_PreviewPipeline.UI_SetPreviewState(bPreview);
  325.     }
  326.  
  327.     DXCC_ASSERT_EXCEPTIONS_END()
  328.  
  329.     return stat;
  330. }
  331.  
  332. MStatus DXCCExportSelectedCommand::doIt ( const MArgList& Arg)
  333. {
  334.     HRESULT hr= S_OK;
  335.     OPENFILENAMEA open;
  336.     ZeroMemory(&open, sizeof(open));
  337.     char szFilename[MAX_PATH]= "";
  338.     open.lStructSize= sizeof(OPENFILENAME); 
  339.     open.hwndOwner= (HWND)M3dView::applicationShell();
  340.     open.hInstance= (HINSTANCE)GetWindowInstance(open.hwndOwner); 
  341.     open.lpstrFilter= "X-File\0*.x\0"; 
  342.     open.lpstrFile= szFilename;
  343.     open.nMaxFile= sizeof(szFilename);
  344.  
  345.  
  346.  
  347.     if(GetSaveFileNameA(&open))
  348.     {
  349.         char* pExtension= strrchr(szFilename, '.');
  350.         if(!pExtension || (0 != _stricoll(".x", pExtension)))
  351.         {
  352.             strcat(szFilename, ".x");
  353.         };
  354.  
  355.         hr= g_PreviewPipeline.Scene_Export(szFilename, NULL, MPxFileTranslator::FileAccessMode::kSaveAccessMode);
  356.     }
  357.  
  358.     return MS::kSuccess;}
  359.  
  360. MStatus DXCCExportSceneCommand::doIt ( const MArgList& Arg)
  361. {
  362.  
  363.     HRESULT hr= S_OK;
  364.     OPENFILENAMEA open;
  365.     ZeroMemory(&open, sizeof(open));
  366.     char szFilename[MAX_PATH]= "";
  367.     open.lStructSize= sizeof(OPENFILENAME); 
  368.     open.hwndOwner= (HWND)M3dView::applicationShell();
  369.     open.hInstance= (HINSTANCE)GetWindowInstance(open.hwndOwner); 
  370.     open.lpstrFilter= "X-File\0*.x\0"; 
  371.     open.lpstrFile= szFilename;
  372.     open.nMaxFile= sizeof(szFilename);
  373.  
  374.  
  375.  
  376.     if(GetSaveFileNameA(&open))
  377.     {
  378.         char* pExtension= strrchr(szFilename, '.');
  379.         if(!pExtension || (0 != _stricoll(".x", pExtension)))
  380.         {
  381.             strcat(szFilename, ".x");
  382.         };
  383.  
  384.         hr= g_PreviewPipeline.Scene_Export(szFilename, NULL, MPxFileTranslator::FileAccessMode::kSaveAccessMode);
  385.     }
  386.  
  387.     return MS::kSuccess;
  388. }
  389.  
  390. MStatus DXCCFrontViewCommand::doIt ( const MArgList& Arg)
  391. {
  392.     MStatus stat;
  393.     stat= DCCUnifiedViewerCommand(Arg, "front");
  394.     return stat;
  395. }
  396.  
  397. MStatus DXCCSideViewCommand::doIt ( const MArgList& Arg)
  398. {
  399.     MStatus stat;
  400.     stat= DCCUnifiedViewerCommand(Arg, "side");
  401.     return stat;
  402. }
  403.  
  404. MStatus DXCCTopViewCommand::doIt ( const MArgList& Arg)
  405. {
  406.     MStatus stat;
  407.     stat= DCCUnifiedViewerCommand(Arg, "top");
  408.     return stat;
  409. }
  410.  
  411. MStatus DXCCPerspectiveViewCommand::doIt ( const MArgList& Arg)
  412. {
  413.     MStatus stat;
  414.     stat= DCCUnifiedViewerCommand(Arg, "persp");
  415.     return stat;
  416. }
  417.  
  418. MStatus DXCCFloatingViewCommand::doIt ( const MArgList& Arg)
  419. {
  420.     MStatus stat;
  421.     stat= DCCUnifiedViewerCommand(Arg, NULL);
  422.     return stat;
  423. }
  424.  
  425. XFileTranslator::~XFileTranslator()
  426. {
  427.     return;
  428. };    
  429.  
  430. //-----------------------------------------------------------------------------
  431. // Name: initializePlugin()
  432. // Desc: Initializes the Maya XFile Exporter plugin
  433. //-----------------------------------------------------------------------------
  434.  
  435. MStatus    
  436. initializePlugin(MObject obj)
  437. {
  438.  
  439.  
  440.     MStatus stat = MS::kSuccess;
  441.  
  442.     DXCC_ASSERT_EXCEPTIONS_BEGIN()
  443.  
  444.  
  445.     TCHAR szPlugin[MAX_PATH];
  446.     TCHAR PluginFilePath[MAX_PATH];
  447.     TCHAR* PluginFileName= NULL;
  448.  
  449.     HMODULE hPluginModule= GetModuleHandle(TEXT(THISFILENAME));
  450.     DWORD OldLength= GetEnvironmentVariable(TEXT("PATH"),NULL,0);
  451.     DWORD ExtLength= GetModuleFileName(hPluginModule, szPlugin, MAX_PATH);
  452.     GetFullPathName(szPlugin, MAX_PATH, PluginFilePath, &PluginFileName);
  453.     PluginFileName[0]= TEXT('\0');
  454.     ExtLength= _tcslen(PluginFilePath)+1;
  455.  
  456.     DWORD NewLength= OldLength + ExtLength + 2;
  457.     LPTSTR szPath= (LPTSTR)_alloca( sizeof(TCHAR) * NewLength );
  458.  
  459.     if(NewLength > GetEnvironmentVariable(TEXT("PATH") , szPath , NewLength))
  460.     {
  461.         if(szPath[OldLength-2] != TEXT(';'))
  462.         {
  463.             szPath[OldLength-1]= TEXT(';');
  464.             szPath[OldLength]= TEXT('\0');
  465.             OldLength++;
  466.         }
  467.  
  468.         if(_tcsncpy( szPath+OldLength-1, PluginFilePath, ExtLength ))
  469.         {
  470.             szPath[OldLength+ExtLength-1]= TEXT(';');
  471.             szPath[OldLength+ExtLength]= TEXT('\0');
  472.         }
  473.  
  474.  
  475.            SetEnvironmentVariable(TEXT("PATH"), szPath);
  476.     }
  477.  
  478.  
  479.  
  480.  
  481.     MFnPlugin plugin(obj, "Microsoft", "5.0", "Any");
  482.     const MString DirectXShader_UserClassify( "shader/surface" );
  483.     MArgList args;
  484.  
  485. #ifdef _DEBUG
  486.     MGlobal::startErrorLogging("c:\\D3DMayaExportXErrorLog.txt");
  487. #endif
  488.  
  489.     g_PreviewPipeline.CallbackId_Exiting= MSceneMessage::addCallback( MSceneMessage::Message::kMayaExiting, CMayaPreviewPipeline::Callback_MayaExiting, NULL, NULL);
  490.     
  491.     //Menu Creation
  492.     MGlobal::executeCommand("source DirectX", true, true);
  493.  
  494.  
  495.  
  496.     g_PreviewPipeline.Create();
  497.  
  498.     stat= plugin.registerNode( 
  499.         DXCC_SHADER, 
  500.         DirectXShader::id, 
  501.         DirectXShader::creator, 
  502.         DirectXShader::initialize, 
  503.         MPxNode::kDependNode, 
  504.         &DirectXShader_UserClassify );
  505.     CHECK_MSTATUS(stat);
  506.  
  507.     // register the translator
  508.     stat = plugin.registerFileTranslator(DXCC_EXPORTER,            // name
  509.                                          NULL,        // icon
  510.                                          XFileTranslator::creator,    
  511.                                          NULL,        // script
  512.                                          NULL,
  513.                                          false);
  514.     CHECK_MSTATUS(stat);
  515.  
  516.     CHECK_MSTATUS(stat= plugin.registerCommand( DXCC_PREVIEW_TOGGLE ,  DXCCPreviewToggleCommand::creator ));
  517.     CHECK_MSTATUS(stat= plugin.registerCommand( DXCC_GATHER_ANIMATION,  DXCCGatherAnimationCommand::creator ));
  518.     CHECK_MSTATUS(stat= plugin.registerCommand( DXCC_REBUILD_SCENE,  DXCCRebuildSceneCommand::creator ));
  519.     CHECK_MSTATUS(stat= plugin.registerCommand( DXCC_REBUILD_SELECTED,  DCCRebuildSelectedCommand::creator ));
  520.     CHECK_MSTATUS(stat= plugin.registerCommand( DXCC_EXPORT_SCENE,  DXCCExportSceneCommand::creator ));
  521.     CHECK_MSTATUS(stat= plugin.registerCommand( DXCC_EXPORT_SELECTED,  DXCCExportSelectedCommand::creator ));
  522.     CHECK_MSTATUS(stat= plugin.registerCommand( DXCC_VIEW_FLOATING,  DXCCFloatingViewCommand::creator ));
  523.     CHECK_MSTATUS(stat= plugin.registerCommand( DXCC_VIEW_FRONT,  DXCCFrontViewCommand::creator ));
  524.     CHECK_MSTATUS(stat= plugin.registerCommand( DXCC_VIEW_SIDE,  DXCCSideViewCommand::creator ));
  525.     CHECK_MSTATUS(stat= plugin.registerCommand( DXCC_VIEW_TOP,  DXCCTopViewCommand::creator ));
  526.     CHECK_MSTATUS(stat= plugin.registerCommand( DXCC_VIEW_PERSP,  DXCCPerspectiveViewCommand::creator ));
  527.  
  528.  
  529.     //Scene Registration ... 
  530.     g_PreviewPipeline.Scene_Register();
  531.  
  532.     D3DPRESENT_PARAMETERS pp = {0};
  533.     pp.BackBufferWidth = 640;
  534.     pp.BackBufferHeight = 480;
  535.     pp.BackBufferCount = 1;
  536.     pp.MultiSampleType = D3DMULTISAMPLE_NONE;
  537.     pp.MultiSampleQuality = 0;
  538.     pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
  539.     pp.hDeviceWindow = NULL;
  540.     pp.Windowed = true;
  541.     pp.EnableAutoDepthStencil = true;
  542.     pp.AutoDepthStencilFormat = D3DFMT_D16;
  543.     pp.FullScreen_RefreshRateInHz = 0;
  544.     pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
  545.  
  546.     g_PreviewPipeline.g_Viewer.Create( &g_PreviewPipeline, &pp );
  547.     
  548.     DXCC_ASSERT_EXCEPTIONS_END()
  549.  
  550.     return stat;
  551. };
  552.  
  553.  
  554. //-----------------------------------------------------------------------------
  555. // Name: uninitializePlugin()
  556. // Desc: Uninitializes the Maya XFile Exporter plugin
  557. //-----------------------------------------------------------------------------
  558.  
  559.  
  560. MStatus    
  561. uninitializePlugin(MObject obj) 
  562. {
  563.     MStatus stat = MS::kSuccess;
  564.     try
  565.     {
  566.         MFnPlugin plugin(obj);
  567.  
  568.         CMayaPreviewPipeline::Callback_MayaExiting(NULL);
  569.  
  570.         stat = plugin.deregisterNode( DirectXShader::id );
  571.         stat = plugin.deregisterFileTranslator(DXCC_EXPORTER);
  572.         stat = plugin.deregisterCommand(DXCC_PREVIEW_TOGGLE);
  573.         stat = plugin.deregisterCommand(DXCC_GATHER_ANIMATION);
  574.         stat = plugin.deregisterCommand(DXCC_REBUILD_SCENE);
  575.         stat = plugin.deregisterCommand(DXCC_REBUILD_SELECTED);
  576.         stat = plugin.deregisterCommand(DXCC_EXPORT_SCENE);
  577.         stat = plugin.deregisterCommand(DXCC_EXPORT_SELECTED);
  578.         stat = plugin.deregisterCommand(DXCC_VIEW_FLOATING);
  579.         stat = plugin.deregisterCommand(DXCC_VIEW_TOP);
  580.         stat = plugin.deregisterCommand(DXCC_VIEW_SIDE);
  581.         stat = plugin.deregisterCommand(DXCC_VIEW_FRONT);
  582.         stat = plugin.deregisterCommand(DXCC_VIEW_PERSP);
  583.     
  584.         MGlobal::executeCommand("DirectX_RemoveMenu()");
  585.  
  586.     }
  587.     catch( ... )
  588.     {
  589.     }
  590.  
  591.     return stat;
  592. }
  593.  
  594.  
  595. void CMayaPreviewPipeline::Callback_MayaExiting( void* clientData )
  596. {
  597.         CPipelineLock Lock;
  598.  
  599.         //if we get this lock then we are ready to end because we 
  600.         g_PreviewPipeline.SceneWriteLock(true, Lock); 
  601.         
  602.         g_PreviewPipeline.g_Viewer.Destroy();
  603.  
  604.         g_PreviewPipeline.Destroy();
  605.     
  606.         g_PreviewPipeline.SceneWriteUnlock(Lock); 
  607.  
  608.  
  609.     return;
  610. }
  611.  
  612.  
  613. //-----------------------------------------------------------------------------
  614. // XFILETRANSLATOR MEMBER FUNCTIONS
  615. //-----------------------------------------------------------------------------
  616.  void*        XFileTranslator::creator()                    
  617. { 
  618.     return new XFileTranslator(); 
  619. };
  620.  
  621. MStatus        XFileTranslator::reader(const MFileObject& file, const MString& optionsString, MPxFileTranslator::FileAccessMode mode) 
  622. { 
  623.     return MS::kSuccess; 
  624. };
  625.  
  626. bool        XFileTranslator::haveReadMethod() const        
  627. { 
  628.     return false; 
  629. };
  630.  
  631. bool        XFileTranslator::haveWriteMethod() const        
  632. { 
  633.     return true; 
  634. };
  635.  
  636. MString     XFileTranslator::defaultExtension() const    
  637. { 
  638.     return "x"; 
  639. }
  640.  
  641. MString     XFileTranslator::filter() const                
  642. { 
  643.     return "*.x"; 
  644. }
  645.  
  646. MPxFileTranslator::MFileKind 
  647. XFileTranslator::identifyFile(    
  648.     const MFileObject& fileName,
  649.     const char* buffer,
  650.     short size) const
  651. { 
  652.     char *extension= strchr(fileName.name().asChar(), '.');
  653.     if(0==_stricoll(".x", extension))
  654.     {
  655.         return MFileKind::kIsMyFileType;
  656.     }
  657.     else
  658.     {
  659.         return MFileKind::kNotMyFileType; 
  660.     }
  661. }
  662.  
  663. MStatus    
  664. XFileTranslator::writer(
  665.             const MFileObject& mfoXFile,            // save file object
  666.             const MString& msOptions,                // options string
  667.             MPxFileTranslator::FileAccessMode mode)    // options string
  668. {
  669.     HRESULT hr = S_OK;
  670.     MStatus stat = MS::kSuccess;
  671.  
  672.     MString    msFile= mfoXFile.fullName();
  673.     char* pExtension= strrchr(msFile.asChar(), '.');
  674.     if(!pExtension || (0 != _stricoll(".x", pExtension)))
  675.     {
  676.         msFile += ".x";
  677.     };
  678.  
  679.     hr= g_PreviewPipeline.Scene_Export(msFile.asChar(), msOptions.asChar(), mode);
  680.     if(FAILED(hr))
  681.     {
  682.         stat= MS::kFailure;
  683.         goto e_Exit;
  684.     };
  685.  
  686. e_Exit:
  687.     return stat;
  688. }
  689.  
  690.  
  691. void* DirectXShader::creator()
  692. {
  693.     return new DirectXShader();
  694. }
  695.  
  696.  
  697. // The initialize method is called only once when the node is first
  698. // registered with Maya. In this method you define the attributes of the
  699. // node, what data comes in and goes out of the node that other nodes may
  700. // want to connect to. 
  701. //
  702.  
  703. MStatus DirectXShader::initialize()
  704. {
  705.     MFnNumericAttribute nAttr; 
  706.     MFnTypedAttribute tAttr; 
  707.  
  708.     MStatus status; 
  709.  
  710.     if(DirectXShader::FxDialogEvent == NULL)
  711.     {
  712.         DirectXShader::FxDialogEvent= CreateEventA(NULL, TRUE, TRUE, "FxDialogEvent");
  713.         SetEvent(DirectXShader::FxDialogEvent);
  714.     }
  715.  
  716.  
  717.     // Input Attributes
  718.     aColorR = nAttr.create( "colorR", "cr",MFnNumericData::kFloat, 0, &status );
  719.     CHECK_MSTATUS( status );
  720.     CHECK_MSTATUS( nAttr.setKeyable( true ) );
  721.     CHECK_MSTATUS( nAttr.setStorable( true ) );
  722.     CHECK_MSTATUS( nAttr.setDefault( 0.0f ) );
  723.  
  724.     aColorG = nAttr.create( "colorG", "cg", MFnNumericData::kFloat, 0, &status );
  725.     CHECK_MSTATUS( status );
  726.     CHECK_MSTATUS( nAttr.setKeyable( true ) );
  727.     CHECK_MSTATUS( nAttr.setStorable( true ) );
  728.     CHECK_MSTATUS( nAttr.setDefault( 0.58824f ) );
  729.  
  730.     aColorB = nAttr.create( "colorB", "cb",MFnNumericData::kFloat, 0, &status );
  731.     CHECK_MSTATUS( status );
  732.     CHECK_MSTATUS( nAttr.setKeyable( true ) );
  733.     CHECK_MSTATUS( nAttr.setStorable( true ) );
  734.     CHECK_MSTATUS( nAttr.setDefault( 0.644f ) );
  735.  
  736.     aColor = nAttr.create( "color", "c", aColorR, aColorG, aColorB, &status );
  737.     CHECK_MSTATUS( status );
  738.     CHECK_MSTATUS( nAttr.setKeyable( true ) );
  739.     CHECK_MSTATUS( nAttr.setStorable( true ) );
  740.     CHECK_MSTATUS( nAttr.setDefault( 0.0f, 0.58824f, 0.644f ) );
  741.     CHECK_MSTATUS( nAttr.setUsedAsColor( true ) );
  742.  
  743.     aDXCCCommand = tAttr.create( "Command", "DXC",  MFnData::kString,  MObject::kNullObj , &status );
  744.     CHECK_MSTATUS( status );
  745.     CHECK_MSTATUS( tAttr.setKeyable( false ) );
  746.     CHECK_MSTATUS( tAttr.setStorable( false ) );
  747.     CHECK_MSTATUS( tAttr.setInternal( true ) );
  748. #ifndef _DEBUG
  749.     CHECK_MSTATUS( nAttr.setHidden( true ) );
  750. #endif
  751.  
  752.     aDXCCHandle = nAttr.create( DX_LONG_FXHANDLE, DX_SHORT_FXHANDLE, MFnNumericData::kInt, 0, &status );
  753.     CHECK_MSTATUS( status );
  754.     CHECK_MSTATUS( nAttr.setKeyable( false ) );
  755.     CHECK_MSTATUS( nAttr.setStorable( false ) );
  756.     CHECK_MSTATUS( nAttr.setInternal( false ) );
  757.     CHECK_MSTATUS( nAttr.setHidden( true ) );
  758.  
  759.     // Color Output
  760.     aOutColorR = nAttr.create( "outColorR", "ocr", MFnNumericData::kFloat, 0, &status );
  761.     CHECK_MSTATUS( status );
  762.     
  763.     aOutColorG = nAttr.create( "outColorG", "ocg", MFnNumericData::kFloat, 0, &status );
  764.     CHECK_MSTATUS( status );
  765.     
  766.     aOutColorB = nAttr.create( "outColorB", "ocb", MFnNumericData::kFloat, 0, &status );
  767.     CHECK_MSTATUS( status );
  768.     
  769.     aOutColor = nAttr.create( "outColor", "oc", aOutColorR, aOutColorG, aOutColorB, &status );
  770.     CHECK_MSTATUS( status );
  771.     
  772.     CHECK_MSTATUS( nAttr.setHidden( false ) );
  773.     CHECK_MSTATUS( nAttr.setReadable( true ) );
  774.     CHECK_MSTATUS( nAttr.setWritable( false ) );
  775.  
  776.     // Camera Normals
  777.     aNormalCameraX = nAttr.create( "normalCameraX", "nx", MFnNumericData::kFloat, 0, &status );
  778.     CHECK_MSTATUS( status );
  779.     CHECK_MSTATUS( nAttr.setStorable( false ) );
  780.     CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  781.  
  782.     aNormalCameraY = nAttr.create( "normalCameraY", "ny", MFnNumericData::kFloat, 0, &status );
  783.     CHECK_MSTATUS( status );
  784.     CHECK_MSTATUS( nAttr.setStorable( false ) );
  785.     CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  786.  
  787.     aNormalCameraZ = nAttr.create( "normalCameraZ", "nz", MFnNumericData::kFloat, 0, &status );
  788.     CHECK_MSTATUS( status );
  789.     CHECK_MSTATUS( nAttr.setStorable( false ) );
  790.     CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  791.  
  792.     aNormalCamera = nAttr.create( "normalCamera","n", aNormalCameraX, aNormalCameraY, aNormalCameraZ, &status );
  793.     CHECK_MSTATUS( status );
  794.     CHECK_MSTATUS( nAttr.setStorable( false ) );
  795.     CHECK_MSTATUS( nAttr.setDefault( 1.0f, 1.0f, 1.0f ) );
  796.     CHECK_MSTATUS( nAttr.setHidden( true ) );
  797.  
  798.  
  799.     // Next we will add the attributes we have defined to the node
  800.     CHECK_MSTATUS( addAttribute( aDXCCCommand ) );
  801.     CHECK_MSTATUS( addAttribute( aDXCCHandle ) );
  802.     CHECK_MSTATUS( addAttribute( aColor ) );
  803.     CHECK_MSTATUS( addAttribute( aOutColor ) );
  804.     CHECK_MSTATUS( addAttribute( aNormalCamera ) );
  805.  
  806.     CHECK_MSTATUS( attributeAffects( aColorR, aOutColor ) );
  807.     CHECK_MSTATUS( attributeAffects( aColorG, aOutColor ) );
  808.     CHECK_MSTATUS( attributeAffects( aColorB, aOutColor ) );
  809.     CHECK_MSTATUS( attributeAffects( aColor, aOutColor ) );
  810.     CHECK_MSTATUS( attributeAffects( aNormalCameraX, aOutColor ) );
  811.     CHECK_MSTATUS( attributeAffects( aNormalCameraY, aOutColor ) );
  812.     CHECK_MSTATUS( attributeAffects( aNormalCameraZ, aOutColor ) );
  813.     CHECK_MSTATUS( attributeAffects( aNormalCamera, aOutColor ) );
  814.  
  815.     return( MS::kSuccess );
  816. }
  817.  
  818. void DirectXShader::postConstructor( )
  819. {
  820.     HRESULT hr= S_OK; 
  821.     MStatus status= MStatus::kSuccess; 
  822.     int iHandle= 0;
  823.     DXCCHANDLE hHandle= NULL;
  824.  
  825.     LPDXCCRESOURCE pResource= NULL;
  826.  
  827.     setMPSafe( true );
  828.  
  829.     MObject object= thisMObject();
  830.     MPlug plug(object, aDXCCHandle);
  831.  
  832.     hr= g_PreviewPipeline.AccessManager()->CreateResource(NULL, IID_NULL, false, &pResource);
  833.     if(DXCC_FAILED(hr))
  834.         DXCC_GOTO_EXIT(e_Exit, TRUE);
  835.  
  836.     g_PreviewPipeline.TriggerManagerEvents.OnResourceAdd(pResource);
  837.  
  838.     CHECK_MSTATUS( plug.setValue((INT)pResource->GetHandle()) );
  839.  
  840. e_Exit:
  841.     DXCC_RELEASE(pResource);
  842.  
  843.     return;
  844. }
  845.  
  846. bool DirectXShader::setInternalValue( const MPlug& plug, const MDataHandle& dataIn)
  847. {
  848.     HRESULT hr= S_OK;
  849.     MStatus status= MStatus::kSuccess; 
  850.  
  851.     if((plug == aDXCCCommand) && GetSingleObject(false, DirectXShader::FxDialogEvent))
  852.     {
  853.         ResetEvent(DirectXShader::FxDialogEvent);
  854.  
  855.         //BOOL bModal;
  856.         int iHandle;
  857.         DXCCHANDLE hHandle;
  858.         LPDIRECT3DDEVICE9 pDevice= NULL;
  859.         LPDXCCRESOURCE pResource= NULL;
  860.         MString& mayaCommand= dataIn.asString();
  861.         const char* strCommand= mayaCommand.asChar();
  862.  
  863.         MPlug plugMaterial(plug.node(), aDXCCHandle);
  864.         plugMaterial.getValue(iHandle);
  865.         hHandle= (DXCCHANDLE)iHandle;
  866.  
  867.         hr= g_PreviewPipeline.AccessManager()->FindResourceByHandle(hHandle, &pResource);
  868.         if(DXCC_FAILED(hr))
  869.             DXCC_GOTO_EXIT(e_Exit, TRUE);
  870.  
  871.  
  872.         if(0==lstrcmpiA(strCommand, "open"))
  873.         {
  874.  
  875.             hr= g_PreviewPipeline.AccessEngine()->GetD3DDevice(&pDevice);
  876.             if(DXCC_FAILED(hr))
  877.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  878.     
  879.  
  880.             hr= DXCCShowEffectDialog(
  881.                     (HWND)M3dView::applicationShell(),
  882.                     pDevice,
  883.                     g_PreviewPipeline.AccessManager(),
  884.                     pResource,
  885.                     this, 
  886.                     TRUE,
  887.                     FALSE);
  888.             if(DXCC_FAILED(hr))
  889.             {
  890.                 SetEvent(DirectXShader::FxDialogEvent);
  891.                 DXCC_GOTO_EXIT(e_Exit, TRUE);
  892.             }
  893.         }
  894.         else
  895.         {
  896.             SetEvent(DirectXShader::FxDialogEvent);
  897.         }
  898.  
  899. e_Exit:
  900.         DXCC_RELEASE(pDevice);
  901.         DXCC_RELEASE(pResource);
  902.  
  903.  
  904.         return TRUE;
  905.     }
  906.     else
  907.     {
  908.         return MPxNode::setInternalValue(plug, dataIn);
  909.     }
  910. }
  911.  
  912.  
  913. HRESULT DirectXShader::OnPostLoad( 
  914.     HWND hDialog, 
  915.     LPDIRECT3DDEVICE9 pDevice,
  916.     LPDXCCMANAGER pManager,
  917.     LPDXCCRESOURCE pResource,//recycle me
  918.     LPCSTR szNewEffectFilename) 
  919. {
  920.     CPipelineLock SceneLock;
  921.  
  922.     g_PreviewPipeline.SceneReadLock(true, SceneLock);
  923.  
  924.     bool FoundInDirtyBin= false;
  925.     for(UINT i = 0; i < g_PreviewPipeline.DirtyShaders.size(); i++)
  926.     {
  927.         if(g_PreviewPipeline.DirtyShaders[i]==pResource->GetHandle())
  928.         {
  929.             FoundInDirtyBin=true;
  930.             break;
  931.         }
  932.     }
  933.     if(!FoundInDirtyBin)
  934.     {
  935.         g_PreviewPipeline.DirtyShaders.push_back(pResource->GetHandle());
  936.     }
  937.  
  938.     g_PreviewPipeline.SceneReadUnlock(SceneLock);
  939.  
  940.     return S_OK;
  941. }
  942.  
  943. HRESULT DirectXShader::OnClose(  
  944.     HWND hDialog, 
  945.      LPDIRECT3DDEVICE9 pDevice,
  946.      LPDXCCMANAGER pManager,
  947.      LPDXCCRESOURCE pResource)
  948. {
  949.     SetEvent(DirectXShader::FxDialogEvent);
  950.  
  951.     return S_OK; 
  952. }
  953.  
  954. MStatus DirectXShader::compute( const MPlug& plug, MDataBlock& block ) 
  955. { 
  956.     // The plug parameter will allow us to determine which output attribute
  957.     // needs to be calculated.
  958.     //
  959.     if( plug == aOutColor
  960.             || plug == aOutColorR
  961.             || plug == aOutColorG
  962.             || plug == aOutColorB)
  963.     {
  964.         MStatus status= MS::kSuccess;
  965.         MFloatVector resultColor( 0.0, 0.0, 0.0 ); 
  966.  
  967.     
  968.         // Get surface shading parameters from input block
  969.         //
  970.         MFloatVector& surfaceNormal = block.inputValue( aNormalCamera,
  971.                 &status ).asFloatVector();
  972.         CHECK_MSTATUS( status );
  973.  
  974.         MFloatVector& surfaceColor = block.inputValue( aColor,
  975.                 &status ).asFloatVector();
  976.         CHECK_MSTATUS( status );
  977.  
  978.         // Factor incident light with surface color and add incandescence
  979.         //
  980.  
  981.         float dot= -surfaceNormal[1];
  982.         if(dot < 0) dot = 0;
  983.         resultColor[0] = dot * surfaceColor[0];
  984.         resultColor[1] = dot * surfaceColor[1];
  985.         resultColor[2] = dot * surfaceColor[2];
  986.  
  987.  
  988.         if ( plug == aOutColor || plug == aOutColorR || plug == aOutColorG
  989.                 || plug == aOutColorB)
  990.         {
  991.             // Get the handle to the attribute
  992.             //
  993.             MDataHandle outColorHandle = block.outputValue( aOutColor,
  994.                     &status );
  995.             CHECK_MSTATUS( status );
  996.             MFloatVector& outColor = outColorHandle.asFloatVector();
  997.         
  998.             outColor = resultColor;        // Set the output value
  999.             outColorHandle.setClean(); // Mark the output value as EraseInvalidTags
  1000.         }
  1001.     } 
  1002.     else
  1003.     {
  1004.         return( MS::kUnknownParameter ); // We got an unexpected plug
  1005.     }
  1006.  
  1007.     return( MS::kSuccess );
  1008. }
  1009.  
  1010.  
  1011.  
  1012.  
  1013.